package ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.negocio.Simulador;

public class Carro implements Entidad {

	private Long id = null;
	private Color color = null;
	private Posicion posicion = null;
	private Recipiente recipiente = null;
	private Infraestructura infraestructura = null;
	private Sensor sensor = null;
	private EnumSentido sentido = null;
	private EnumOrden orden = null;
	private int velocidad = 1;
	private int cantidadVueltasDescanso = 0;
	private boolean parado = false;

	public Carro() {
		sensor = new Sensor(this);
		sensor.getTipo().add(EnumEvento.HUMEDAD);
		sensor.getTipo().add(EnumEvento.LLUVIA);
		sensor.getTipo().add(EnumEvento.OBSTACULO);
		sensor.getTipo().add(EnumEvento.PROXIMIDAD);
		sensor.getTipo().add(EnumEvento.VIENTO);
	}

	public Carro(Color color, double x, double y) {
		this.color = color;
		this.posicion = new Posicion(x, y);
		this.sensor = new Sensor(this);
	}

	private static Long idFactory = null;

	private static Long getIdFactory() {
		if (idFactory == null) {
			idFactory = new Long(0);
		}
		idFactory = new Long(idFactory.longValue() + 1);
		return idFactory;
	}

	public static Carro factory(Infraestructura infraestructura) {
		Carro carro = null;
		carro = new Carro();
		carro.setId(getIdFactory());
		carro.setRecipiente(null);
		carro.setColor(colorFactory());
		carro.setPosicion(Posicion.factory());
		carro.setInfraestructura(infraestructura);
		carro.setSentido(EnumSentido.HACIA_RECIPIENTE);
		carro.setOrden(EnumOrden.IR_BUSCAR_RECIPIENTE);
		return carro;
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.Infraestructura
	 * #getTipo()
	 */
	@Override
	public String getTipo() {
		return "Carro";
	}

	public static Color colorFactory() {
		switch (idFactory.intValue()) {
		case (1):
			return new Color(1.0f, 0.0f, 0.0f, 0.75f);
		case (2):
			return new Color(0.0f, 1.0f, 0.0f, 0.75f);
		default:
			return new Color(0.0f, 0.0f, 1.0f, 0.75f);
		}
	}

	/**
	 * @return the id
	 */
	public Long getId() {
		return id;
	}

	/**
	 * @param id
	 *            the id to set
	 */
	public void setId(Long id) {
		this.id = id;
	}

	/**
	 * @return the recipiente
	 */
	public Recipiente getRecipiente() {
		return recipiente;
	}

	/**
	 * @param recipiente
	 *            the recipiente to set
	 */
	public void setRecipiente(Recipiente recipiente) {
		this.recipiente = recipiente;
	}

	public void setColor(Color color) {
		this.color = color;
	}

	public Color getColor() {
		return color;
	}

	public void setPosicion(Posicion posicion) {
		this.posicion = posicion;
	}

	public Posicion getPosicion() {
		return posicion;
	}

	public void setSensor(Sensor sensor) {
		this.sensor = sensor;
	}

	public Sensor getSensor() {
		return sensor;
	}

	/**
	 * @return the infraestructura
	 */
	public Infraestructura getInfraestructura() {
		return infraestructura;
	}

	/**
	 * @param infraestructura
	 *            the infraestructura to set
	 */
	public void setInfraestructura(Infraestructura infraestructura) {
		if (this.infraestructura != null) {
			if (this.infraestructura.getCarro() != null) {
				this.infraestructura.eliminarEvento(this);
				this.infraestructura.setCarro(null);
			}
			this.eliminarEvento(this.infraestructura);
		}
		this.infraestructura = infraestructura;
		this.infraestructura.setCarro(this);
	}

	@Override
	public String toString() {
		StringBuffer retorno = new StringBuffer();
		retorno.append(Configuracion.SEPARADOR);
		retorno.append("----------------------------------" + Configuracion.SEPARADOR);
		retorno.append("Carro id = " + id.toString() + Configuracion.SEPARADOR);
		retorno.append("    Color: ");
		switch (id.intValue()) {
		case(1):
			retorno.append("Rojo");
			break;
		case(2):
			retorno.append("Verde");
			break;
		case(3):
			retorno.append("Azul");
			break;
		}
		retorno.append(Configuracion.SEPARADOR);
		retorno.append("    Orden: " + orden.getValor() + Configuracion.SEPARADOR);
		retorno.append("    Sobre: " + infraestructura.toString() + Configuracion.SEPARADOR);
		retorno.append("        Posicion: X " + posicion.getX() + Configuracion.SEPARADOR);
		retorno.append("        Posicion: Y " + posicion.getY() + Configuracion.SEPARADOR);
		retorno.append("    Velocidad: " + velocidad + Configuracion.SEPARADOR);
		retorno.append("    Sentido: " + sentido.getValor() + Configuracion.SEPARADOR);
		if (recipiente == null) {
			retorno.append("    Estado: Vacio" + Configuracion.SEPARADOR);
		} else {
			retorno.append("    Estado: Con recipiente" + Configuracion.SEPARADOR);
		}
		retorno.append("    Sensor:" + Configuracion.SEPARADOR);
		for (Evento evento: sensor.getListEvento()) {
			retorno.append("        " + evento.getTipoEvento().getValor() + "\n");
		}
		return retorno.toString();
	}

	/**
	 * @return the sentido
	 */
	public EnumSentido getSentido() {
		return sentido;
	}

	/**
	 * @param sentido
	 *            the sentido to set
	 */
	public void setSentido(EnumSentido sentido) {
		this.sentido = sentido;
	}

	/**
	 * @return the orden
	 */
	public EnumOrden getOrden() {
		return orden;
	}
	
	public void recibirEventoObstaculo(Entidad emisor) {
		if (sensor.getListEvento() == null) {
			sensor.setListEvento(new ArrayList<Evento>());
		}
		sensor.recibirEvento(
				Evento.factory(EnumEvento.OBSTACULO, null, "OBSTACULO",
						Simulador.CICLOS, emisor));
	}

	public void recibirEventoProximidad(Entidad emisor) {
		if (sensor.getListEvento() == null) {
			sensor.setListEvento(new ArrayList<Evento>());
		}
		sensor.recibirEvento(
				Evento.factory(EnumEvento.PROXIMIDAD, null, "PROXIMIDAD",
						Simulador.CICLOS, emisor));
	}
	
	public void recibirEventoHumedad(Entidad emisor, String valor) {
		if (sensor.getListEvento() == null) {
			sensor.setListEvento(new ArrayList<Evento>());
		}
		sensor.recibirEvento(
				Evento.factory(EnumEvento.HUMEDAD, valor, "HUMEDAD",
						Simulador.CICLOS, null));
	}

	public void recibirEventoLluvia(Entidad emisor, String valor) {
		if (sensor.getListEvento() == null) {
			sensor.setListEvento(new ArrayList<Evento>());
		}
		sensor.recibirEvento(
				Evento.factory(EnumEvento.LLUVIA, valor, "LLUVIA",
						Simulador.CICLOS, null));
	}

	public void recibirEventoViento(Entidad emisor, String valor) {
		if (sensor.getListEvento() == null) {
			sensor.setListEvento(new ArrayList<Evento>());
		}
		sensor.recibirEvento(
				Evento.factory(EnumEvento.VIENTO, valor, "VIENTO",
						Simulador.CICLOS, null));
	}
	
	@Override
	public void eliminarEvento(Entidad emisor) {
		sensor.eliminarEvento(emisor);
	}
	
	public void eliminarEventoViento() {
		List<Evento> listRemover = new ArrayList<Evento>();
		if (!sensor.getListEvento().isEmpty()) {
			for (Evento evento : sensor.getListEvento()) {
				if (evento.getTipoEvento().equals(EnumEvento.VIENTO)) {
					listRemover.add(evento);
				}
			}
		}
		if (!listRemover.isEmpty()) {
			for (Evento evento : listRemover) {
				sensor.getListEvento().remove(evento);
			}
		}
		listRemover.clear();
	}

	/**
	 * @param orden
	 *            the orden to set
	 */
	public void setOrden(EnumOrden orden) {
		this.orden = orden;
	}

	/**
	 * @return the velocidad
	 */
	public int getVelocidad() {
		if (parado) {
			velocidad = 0;
			return velocidad;
		}
		if (infraestructura != null) {
			if (infraestructura.getTipo().equals("Deposito")) {
				velocidad = 0;
				return velocidad;
			} else if (infraestructura.getTipo().equals("Esclusa")) {
				velocidad = 1;
				return velocidad;
			} else if (infraestructura.getTipo().equals("Compuerta")) {
				velocidad = 1;
				return velocidad;
			}
		}
		boolean hayViento = false;
		if ((infraestructura != null) && (infraestructura.getSensor() != null) && (infraestructura.getSensor().getListEvento() != null)) {
			boolean hayObstaculo = false;
			for (Evento evento: infraestructura.getSensor().getListEvento()) {
				if (evento.getTipoEvento().equals(EnumEvento.OBSTACULO)) {
					hayObstaculo = true;
				}
			}
			if (hayObstaculo) {
				velocidad = 0;
				return velocidad;
			}
		}
		for (Evento evento: sensor.getListEvento()) {
			if (evento.getTipoEvento().equals(EnumEvento.VIENTO)) {
				hayViento = true;
			}
		}
		if (recipiente != null) {
			if (hayViento) {
				velocidad = 1;
			} else {
				velocidad = 2;
			}
		} else {
			velocidad = 3;
		}
		return velocidad;
	}

	/**
	 * @param velocidad the velocidad to set
	 */
	public void setVelocidad(int velocidad) {
		this.velocidad = velocidad;
	}

	/**
	 * @return the cantidadVueltasDescanso
	 */
	public int getCantidadVueltasDescanso() {
		return cantidadVueltasDescanso;
	}

	/**
	 * @param cantidadVueltasDescanso the cantidadVueltasDescanso to set
	 */
	public void setCantidadVueltasDescanso(int cantidadVueltasDescanso) {
		this.cantidadVueltasDescanso = cantidadVueltasDescanso;
	}

	/**
	 * @return the parado
	 */
	public boolean isParado() {
		return parado;
	}

	/**
	 * @param parado the parado to set
	 */
	public void setParado(boolean parado) {
		this.parado = parado;
	}
}